// 图案管理云对象
module.exports = {
	_before: function () {
		// 通用预处理器
		this.startTime = Date.now();
		// 连接数据库
		this.db = uniCloud.database();
	},
	
	/**
	 * 初始化图案数据
	 * @description 从sh_pattern.init_data初始化所有图案数据到sh_pattern集合
	 * @returns {object} 初始化结果
	 */
	async initPatternData() {
		// 校验权限，只有管理员可以执行初始化
		const { userInfo } = this.getClientInfo();
		if (!userInfo || userInfo.role !== 'admin') {
			return {
				errCode: 403,
				errMsg: '权限不足，只有管理员可以执行初始化操作'
			};
		}

		try {
			// 导入初始化脚本
			const initScript = require('../../database/init/sh_pattern_init.js');
			await initScript.run();

			return {
				errCode: 0,
				errMsg: '图案数据初始化成功'
			};
		} catch (error) {
			console.error('图案数据初始化失败:', error);
			return {
				errCode: 500,
				errMsg: '图案数据初始化失败: ' + error.message
			};
		}
	},

	/**
	 * 获取图案列表
	 * @param {string} category 分类
	 * @param {number} page 页码
	 * @param {number} limit 每页数量
	 * @param {string} keyword 搜索关键词
	 * @param {string} sortBy 排序方式
	 * @returns {object} 图案列表
	 */
	async getPatternList({category, page = 1, limit = 20, keyword, sortBy = 'create_time'}) {
		try {
			const db = uniCloud.database();
			const dbCmd = db.command;
			
			let whereCondition = {
				status: 1  // 只获取已发布的图案
			};
			
			// 分类筛选
			if (category && category !== 'all') {
				whereCondition.category = category;
			}
			
			// 关键词搜索
			if (keyword) {
				whereCondition = dbCmd.and([
					whereCondition,
					dbCmd.or([
						{pattern_name: new RegExp(keyword, 'i')},
						{pattern_name_en: new RegExp(keyword, 'i')},
						{tags: dbCmd.in([new RegExp(keyword, 'i')])}
					])
				]);
			}
			
			// 排序条件
			let orderBy = 'create_time';
			let orderType = 'desc';
			
			switch (sortBy) {
				case 'popular':
					orderBy = 'download_count';
					break;
				case 'newest':
					orderBy = 'create_time';
					break;
				case 'favorite':
					orderBy = 'favorite_count';
					break;
				case 'name':
					orderBy = 'pattern_name';
					orderType = 'asc';
					break;
			}
			
			// 分页查询
			const skip = (page - 1) * limit;
			const patternResult = await db.collection('sh_pattern')
				.where(whereCondition)
				.orderBy(orderBy, orderType)
				.skip(skip)
				.limit(limit)
				.get();
			
			// 获取总数
			const countResult = await db.collection('sh_pattern')
				.where(whereCondition)
				.count();

			return {
				errCode: 0,
				errMsg: '获取成功',
				data: {
					list: patternResult.data,
					total: countResult.total,
					page,
					limit,
					totalPages: Math.ceil(countResult.total / limit)
				}
			}
		} catch (error) {
			console.error('获取图案列表失败:', error);
			return {
				errCode: 'GET_PATTERN_LIST_FAILED',
				errMsg: '获取图案列表失败'
			}
		}
	},

	/**
	 * 获取图案详情
	 * @param {string} patternId 图案ID
	 * @returns {object} 图案详情
	 */
	async getPatternDetail({patternId}) {
		if (!patternId) {
			return {
				errCode: 'PARAM_ERROR',
				errMsg: '图案ID不能为空'
			}
		}

		try {
			const db = uniCloud.database();
			
			const patternResult = await db.collection('sh_pattern').doc(patternId).get();
			
			if (patternResult.data.length === 0) {
				return {
					errCode: 'PATTERN_NOT_FOUND',
					errMsg: '图案不存在'
				}
			}

			// 更新下载次数
			await db.collection('sh_pattern').doc(patternId).update({
				download_count: db.command.inc(1),
				update_time: new Date()
			});

			return {
				errCode: 0,
				errMsg: '获取成功',
				data: patternResult.data[0]
			}
		} catch (error) {
			console.error('获取图案详情失败:', error);
			return {
				errCode: 'GET_PATTERN_DETAIL_FAILED',
				errMsg: '获取图案详情失败'
			}
		}
	},

	/**
	 * 获取分类列表
	 * @returns {object} 分类列表
	 */
	async getCategoryList() {
		try {
			const categories = [
				{id: 'all', name: '全部', name_en: 'All'},
				{id: 'nature', name: '自然', name_en: 'Nature'},
				{id: 'animal', name: '动物', name_en: 'Animal'},
				{id: 'abstract', name: '抽象', name_en: 'Abstract'},
				{id: 'geometry', name: '几何', name_en: 'Geometry'},
				{id: 'art', name: '艺术', name_en: 'Art'},
				{id: 'other', name: '其他', name_en: 'Other'}
			];

			return {
				errCode: 0,
				errMsg: '获取成功',
				data: categories
			}
		} catch (error) {
			console.error('获取分类列表失败:', error);
			return {
				errCode: 'GET_CATEGORY_LIST_FAILED',
				errMsg: '获取分类列表失败'
			}
		}
	},

	/**
	 * 获取精选图案
	 * @param {number} limit 数量限制
	 * @returns {object} 精选图案列表
	 */
	async getFeaturedPatterns({limit = 10}) {
		try {
			const db = uniCloud.database();
			
			const patternResult = await db.collection('sh_pattern')
				.where({
					status: 1,
					is_featured: true
				})
				.orderBy('create_time', 'desc')
				.limit(limit)
				.get();

			return {
				errCode: 0,
				errMsg: '获取成功',
				data: patternResult.data
			}
		} catch (error) {
			console.error('获取精选图案失败:', error);
			return {
				errCode: 'GET_FEATURED_PATTERNS_FAILED',
				errMsg: '获取精选图案失败'
			}
		}
	},
	
	/**
	 * 获取热门图案
	 * @param {number} limit 数量限制
	 * @returns {object} 热门图案列表
	 */
	async getHotPatterns({limit = 10}) {
		try {
			const db = uniCloud.database();
			
			const patternResult = await db.collection('sh_pattern')
				.where({status: 1})
				.orderBy('download_count', 'desc')
				.limit(limit)
				.get();

			return {
				errCode: 0,
				errMsg: '获取成功',
				data: patternResult.data
			}
		} catch (error) {
			console.error('获取热门图案失败:', error);
			return {
				errCode: 'GET_HOT_PATTERNS_FAILED',
				errMsg: '获取热门图案失败'
			}
		}
	},
	
	/**
	 * 获取最新图案
	 * @param {number} limit 数量限制
	 * @returns {object} 最新图案列表
	 */
	async getNewPatterns({limit = 10}) {
		try {
			const db = uniCloud.database();
			
			const patternResult = await db.collection('sh_pattern')
				.where({status: 1})
				.orderBy('create_time', 'desc')
				.limit(limit)
				.get();

			return {
				errCode: 0,
				errMsg: '获取成功',
				data: patternResult.data
			}
		} catch (error) {
			console.error('获取最新图案失败:', error);
			return {
				errCode: 'GET_NEW_PATTERNS_FAILED',
				errMsg: '获取最新图案失败'
			}
		}
	},
	
	/**
	 * 搜索图案
	 * @param {string} keyword 关键词
	 * @param {string} category 分类
	 * @param {number} page 页码
	 * @param {number} limit 每页数量
	 * @param {string} sortBy 排序方式
	 * @returns {object} 搜索结果
	 */
	async searchPatterns({keyword, category, page = 1, limit = 20, sortBy = 'create_time'}) {
		return await this.getPatternList({keyword, category, page, limit, sortBy});
	},
	
	/**
	 * 获取用户收藏的图案
	 * @param {string} userId 用户ID
	 * @param {number} page 页码
	 * @param {number} limit 每页数量
	 * @returns {object} 用户收藏的图案
	 */
	async getUserFavorites({userId, page = 1, limit = 20}) {
		if (!userId) {
			// 获取当前登录用户ID
			const { uid } = this.getClientInfo();
			if (!uid) {
				return {
					errCode: 'NOT_LOGGED_IN',
					errMsg: '用户未登录'
				}
			}
			userId = uid;
		}
		
		try {
			const db = uniCloud.database();
			const $ = db.command.aggregate;
			
			// 获取用户收藏记录
			const favoritesResult = await db.collection('sh_user_favorites')
				.aggregate()
				.match({
					user_id: userId
				})
				.lookup({
					from: 'sh_pattern',
					localField: 'pattern_id',
					foreignField: '_id',
					as: 'pattern'
				})
				.unwind('$pattern')
				.match({
					'pattern.status': 1
				})
				.project({
					_id: 0,
					pattern: 1
				})
				.skip((page - 1) * limit)
				.limit(limit)
				.end();
			
			// 获取总数
			const countResult = await db.collection('sh_user_favorites')
				.where({
					user_id: userId
				})
				.count();
			
			const patterns = favoritesResult.data.map(item => ({...item.pattern, isFavorite: true}));
			
			return {
				errCode: 0,
				errMsg: '获取成功',
				data: {
					patterns,
					total: countResult.total,
					page,
					limit,
					totalPages: Math.ceil(countResult.total / limit)
				}
			}
		} catch (error) {
			console.error('获取用户收藏失败:', error);
			return {
				errCode: 'GET_USER_FAVORITES_FAILED',
				errMsg: '获取用户收藏失败'
			}
		}
	},
	
	/**
	 * 切换图案收藏状态
	 * @param {string} patternId 图案ID
	 * @param {string} action 操作类型: 'add' | 'remove' | 'toggle'
	 * @returns {object} 操作结果
	 */
	async togglePatternFavorite({patternId, action = 'toggle'}) {
		// 获取当前登录用户ID
		const { uid } = this.getClientInfo();
		if (!uid) {
			return {
				errCode: 'NOT_LOGGED_IN',
				errMsg: '用户未登录'
			}
		}
		
		if (!patternId) {
			return {
				errCode: 'PARAM_ERROR',
				errMsg: '图案ID不能为空'
			}
		}
		
		try {
			const db = uniCloud.database();
			
			// 检查图案是否存在
			const patternResult = await db.collection('sh_pattern').doc(patternId).get();
			if (patternResult.data.length === 0) {
				return {
					errCode: 'PATTERN_NOT_FOUND',
					errMsg: '图案不存在'
				}
			}
			
			// 检查是否已收藏
			const favoriteResult = await db.collection('sh_user_favorites')
				.where({
					user_id: uid,
					pattern_id: patternId
				})
				.get();
			
			const isFavorited = favoriteResult.data.length > 0;
			
			// 根据操作类型处理
			if (action === 'add' && isFavorited) {
				return {
					errCode: 0,
					errMsg: '已经收藏过了',
					data: {
						isFavorite: true
					}
				}
			} else if (action === 'remove' && !isFavorited) {
				return {
					errCode: 0,
					errMsg: '未收藏过',
					data: {
						isFavorite: false
					}
				}
			} else if (action === 'toggle' || action === 'add' || action === 'remove') {
				// 切换收藏状态
				const shouldFavorite = action === 'toggle' ? !isFavorited : action === 'add';
				
				if (shouldFavorite) {
					// 添加收藏
					await db.collection('sh_user_favorites').add({
						user_id: uid,
						pattern_id: patternId,
						create_time: new Date()
					});
					
					// 更新收藏计数
					await db.collection('sh_pattern').doc(patternId).update({
						favorite_count: db.command.inc(1)
					});
					
					return {
						errCode: 0,
						errMsg: '收藏成功',
						data: {
							isFavorite: true
						}
					}
				} else {
					// 取消收藏
					await db.collection('sh_user_favorites').where({
						user_id: uid,
						pattern_id: patternId
					}).remove();
					
					// 更新收藏计数（确保不会小于0）
					await db.collection('sh_pattern').doc(patternId).update({
						favorite_count: db.command.inc(-1)
					});
					
					return {
						errCode: 0,
						errMsg: '取消收藏成功',
						data: {
							isFavorite: false
						}
					}
				}
			} else {
				return {
					errCode: 'INVALID_ACTION',
					errMsg: '无效的操作类型'
				}
			}
		} catch (error) {
			console.error('切换收藏状态失败:', error);
			return {
				errCode: 'TOGGLE_FAVORITE_FAILED',
				errMsg: '操作失败'
			}
		}
	},
	
	/**
	 * 检查是否已收藏图案
	 * @param {string} patternId 图案ID
	 * @returns {object} 检查结果
	 */
	async checkFavorite({patternId}) {
		// 获取当前登录用户ID
		const { uid } = this.getClientInfo();
		if (!uid) {
			return {
				errCode: 'NOT_LOGGED_IN',
				errMsg: '用户未登录'
			}
		}
		
		if (!patternId) {
			return {
				errCode: 'PARAM_ERROR',
				errMsg: '图案ID不能为空'
			}
		}
		
		try {
			const db = uniCloud.database();
			
			// 检查是否已收藏
			const favoriteResult = await db.collection('sh_user_favorites')
				.where({
					user_id: uid,
					pattern_id: patternId
				})
				.get();
			
			const isFavorited = favoriteResult.data.length > 0;
			
			return {
				errCode: 0,
				errMsg: '获取成功',
				data: {
					isFavorite: isFavorited
				}
			}
		} catch (error) {
			console.error('检查收藏状态失败:', error);
			return {
				errCode: 'CHECK_FAVORITE_FAILED',
				errMsg: '检查收藏状态失败'
			}
		}
	}
}
